Bi-directional communication between humans and swarm systems begs for efficient languages to communicate information between the humans and the Artificial Intelligence (AI)-enabled agents in a manner that is most appropriate for the context. We discuss the criteria for effective teaming and functional bi-directional communication between humans and AI, and the design choices required to create effective languages. We then present a human-AI-teaming communication language inspired by the Australian Aboriginal language of Jingulu, which we call JSwarm. We present the motivation and structure of the language. An example is used to demonstrate how the language operates for a shepherding swarm guidance task.

The automatic translation of text from one natural language (the source) to another is known as machine translation (the target). It was one of the first applications for computers that were imagined (Weaver, 1949). The translation is tough since it necessitates a thorough understanding of the text in the most general scenario. This is true even for very basic messages, such as one-word "texts." Consider the word "Open" on a store's front door.

In this post, we continue our summaries of the invited talks from the International Joint Conference on Artificial Intelligence (IJCAI-21). This time, we cover the presentations from Yoshua Bengio and Michael Thielscher. Yoshua's talk focussed on the development of what he calls system 2 deep learning. The aim is to incorporate agency, causality, and ideas from human intelligence to advance current deep learning methods, thus enabling better out-of-distribution generalisation. As proposed by Daniel Kahneman, system 1 and system 2 are different types of thinking.

Given a specification $\varphi(X,Y)$ over inputs $X$ and output $Y$, defined over a background theory $\mathbb{T}$, the problem of program synthesis is to design a program $f$ such that $Y=f(X)$ satisfies the specification $\varphi$. Over the past decade, syntax-guided synthesis (SyGuS) has emerged as a dominant approach for program synthesis where in addition to the specification $\varphi$, the end-user also specifies a grammar $L$ to aid the underlying synthesis engine. This paper investigates the feasibility of synthesis techniques without grammar, a sub-class defined as $\mathbb{T}$-constrained synthesis. We show that $\mathbb{T}$-constrained synthesis can be reduced to DQF($\mathbb{T}$), i.e., to the problem of finding a witness of a Dependency Quantified Formula Modulo Theory. When the underlying theory is the theory of bitvectors, the corresponding DQF(BV) problem can be further reduced to Dependency Quantified Boolean Formulas (DQBF). We rely on the progress in DQBF solving to design DQBF-based synthesizers that outperform the domain-specific program synthesis techniques, thereby positioning DQBF as a core representation language for program synthesis. Our empirical analysis shows that $\mathbb{T}$-constrained synthesis can achieve significantly better performance than syntax-guided approaches. Furthermore, the general-purpose DQBF solvers perform on par with domain-specific synthesis techniques.

We introduce the open-ended, modular, self-improving Omega AI unification architecture which is a refinement of Solomonoff's Alpha architecture, as considered from first principles. The architecture embodies several crucial principles of general intelligence including diversity of representations, diversity of data types, integrated memory, modularity, and higher-order cognition. We retain the basic design of a fundamental algorithmic substrate called an "AI kernel" for problem solving and basic cognitive functions like memory, and a larger, modular architecture that re-uses the kernel in many ways. Omega includes eight representation languages and six classes of neural networks, which are briefly introduced. The architecture is intended to initially address data science automation, hence it includes many problem solving methods for statistical tasks. We review the broad software architecture, higher-order cognition, self-improvement, modular neural architectures, intelligent agents, the process and memory hierarchy, hardware abstraction, peer-to-peer computing, and data abstraction facility.

The Alexa Meaning Representation Language (AMRL) is a compositional graph-based semantic representation that includes fine-grained types, properties, actions, and roles and can represent a wide variety of spoken language.  AMRL increases the ability of virtual assistants to represent more complex requests, including logical and conditional statements as well as ones with nested clauses. Due to this representational capacity, the acquisition of large scale data resources is challenging, which limits the accuracy of resulting models. This paper has two primary contributions. First, we develop a linearization of AMRL graphs along with a deep multi-task model that predicts fine-grained types, properties, and intents. Second, we show how to jointly train a model that predicts an existing representation for spoken language understanding (SLU) along with the linearized AMRL parse. The resulting model, which leverages learned embeddings from both tasks, is able to predict the AMRL representation more accurately than other approaches, decreasing the error rates in the full parse by 3.56% absolute and reducing the amount of natively annotated data needed to train accurate parsing models.

The representation language used in one domain is seldom borrowed and adapted to another, because the facilities that were assets for one task become limitations elsewhere. For this reason, most such languages are built from scratch. The goal of the RLL effort is to reduce the amount of time expended in building a representation language, by providing a Representation Language Language, that is, a language that provided the user with the components of many representation languages, and with the ability to integrate them. RLL contains a large library of "representational pieces," for example, the mode of inheritance used by the Examples link of the Units package, or the A-Kind-Of type of slot used in the MIT Frames Representation Language, FRL. A novice user can easily design a language simply by picking an amalgamation of pieces; RLL is responsible for meshing them together into a coherent and working whole.

Interested in the research on machine learning and time-series analysis algorithms able to process big data in an efficient, adaptive, and robust way. Currently focused on their application to Cognitive Stimulation and Rehabilitation (see Innobrain and Cognitio projects) and Autism Spectrum Disorders (see AMATE project). Another topic of my interest is the use of Machine Learning techniques to reason and learn about musical processes like expressive music generation. Currently focused on the study of musical expressivity in Nylon Guitars (see guitarLab) and social tools for music education (see PRAISE). We have studied the issue of expressiveness in the context of tenor saxophon interpretations (see Saxex and TempoExpress systems) in collaboration with the Music Technology Group (UPF).

Overview of GLISP GLISP is a LISP-based language which provides high-level language features not found in ordinary LISP. The GLISP language is implemented by means of a compiler which accepts GLISP as input and produces ordinary LISP as output; this output can be further compiled to machine code by the LISP compiler. The goal of GLISP is to allow structured objects to be reft-trenced in a convenient, succinct language, and to allow the structures of objects to be changed without changing the code which references the objects. The syntax of many GLISP constructs is English-like; much of the power and brevity of GLISP derive from the compiler features necessary to support the relatively informal.

This article proposes a suite of design decisions for the overall design of an Artificial Intelligence, i.e., a software system that exhibits intelligence in the spirit of the early days of A.I. research. The key aspects of the proposal are: (1) The identification of the A.I. system as a software individual that has the properties of integrity and persistence; (2) The construction of a software platform that integrates aspects of incremental programming languages and systems as well as of operating systems, with aspects that are intrinsic to knowledge-based artificial intelligence; (3) The use of a representation language that builds on essential aspects of S-expressions, Lisp, logic and extended set theory, but which is used both as a vehicle for software and as a publication language e.g. in lecture notes; (4) The identification of actions and aggregates of actions as first-class citizens in the representation language and as an important type of data object in the software system. The article also describes the Leonardo software platform, its representation language, its educational resources and its knowledgebase library which is one implementation of these proposed design decisions. Finally it makes a proposal concerning the research paradigm for this research area.